package com.cskaoyan.javase.string._5compare;

import java.util.Arrays;

/**
 * String类的比较大小功能
 * String类中，存在两个用于比较字符串大小的方法，即String比较大小的功能。
 *
 * // String类的比较功能
 * int compareTo(String str)
 * int compareToIgnoreCase(String str)
 *
 * String对象为什么有大小关系呢?怎么确定谁大谁小呢?
 * 既然是比较大小,就需要一个比较大小的规则,compareTo方法的实现就表示一个比较大小的规则
 *
 * String类compareTo方法比较大小的规则是:
 *      1.逐一比较两个字符串对应位置的字符,如果存在不相同的字符,那么就返回它们的编码值之差.
 *          "123".compareTo("abc") --> 返回1的编码值减去a的编码值
 *          "abc".compareTo("aac") --> 返回b的编码值减去a的编码值
 *          "abcd".compareTo("abceee") --> 返回d的编码值减去e的编码值
 *
 *      2.如果逐一比较两个字符串对应位置的字符,发现所有比较的字符都是相同的,这时就返回它们的字符串长度之差.
 *          "abcd".compareTo("abcdeeee") --> 返回前面的字符串长度和后面的字符串长度之差
 *          "abcd".compareTo("abcd") --> 返回前面的字符串长度和后面的字符串长度之差
 *          "abcd".compareTo("a") --> 返回前面的字符串长度和后面的字符串长度之差
 *
 * 那么字符串对象的大小关系如何确定呢?
 * 把这个方法调用看成this String对象-参数String对象
 * 方法如果返回小于0的数,说明 this < 参数对象
 * 方法如果返回大于0的数,说明 this > 参数对象
 * 方法如果返回等于0的数,说明 this = 参数对象
 *
 * 以上确定一个对象的大小关系,就可以实现对该对象容器的排序,比如"从小到大进行排序"
 *
 * 在Java中,让某个类实现Comparable接口，重写compareTo方法表示排序规则
 * 然后实现对象容器中元素从小到大的排序方式，称之为"自然排序"，其中的compareTo方法被称为该类的自然比较方法。
 *
 * 具体来说可以通过以下方法实现对容器元素的自然排序:
 *      1.Arrays.sort(实现了Comparable接口的类的对象数组);
 *      2.Collections.sort(实现了Comparable接口的类的对象集合);
 *
 * @since 11:34
 * @author wuguidong@cskaoyan.onaliyun.com
 */
public class Demo {
    public static void main(String[] args) {
        String s1 = "hello";
        String s2 = "hello";
        // 0 说明s1等于s2
        System.out.println(s1.compareTo(s2));

        // -48 说明"123"小于"abc"
        System.out.println("123".compareTo("abc"));

        // 3 说明"abcd"大于"abcaee"
        System.out.println("abcd".compareTo("abcaee"));

        String[] strs = {"1234567", "123", "123456", "1234"};
        Arrays.sort(strs);
        System.out.println(Arrays.toString(strs));

        System.out.println("-----------------------");
        Student[] stus = new Student[5];
        stus[0] = new Student(10, "张三", 100);
        stus[1] = new Student(18, "马云云123", 70);
        stus[2] = new Student(20, "张晓宇", 30);
        stus[3] = new Student(7, "刘华强2", 10);
        stus[4] = new Student(30, "A", 80);

        // 进行自然排序
        Arrays.sort(stus);

        for (Student s : stus) {
            System.out.println(s);
        }
    }
}

class Student implements Comparable {
    int age;
    String name;
    double score;

    public Student(int age, String name, double score) {
        this.age = age;
        this.name = name;
        this.score = score;
    }

    // 该方法的实现表示一个比较的规则
    @Override
    public int compareTo(Object o) {
        // 规则1: 按照年龄从小到大排序,年龄越小,对象就越小,这时该对象和其它对象比较,方法更应该返回一个负数
        // return this.age - ((Student) o).age;

        // 规则2: 按照成绩由高到低排序
        // 我(this)的成绩越高,反而对象越小,该方法越要返回一个负数
        // return (int) (((Student) o).score - this.score);

        // 规则3: 按名字字符串的长度由长到短进行排序
        // 我(this)的名字越长,反而对象越小,该方法应该返回一个负数
        return ((Student) o).name.length() - name.length();
    }

    @Override
    public String toString() {
        return "Student{" +
                "age=" + age +
                ", name='" + name + '\'' +
                ", score=" + score +
                '}';
    }
}
class A implements Comparable<A>{
    @Override
    public int compareTo(A o) {
        return 0;
    }
}